…+ captured artifact

Adds .github/workflows/link-check.yml as a dedicated workflow so
the README status badge
(https://github.com/EvoMap/evolver/actions/workflows/link-check.yml/badge.svg)
reflects ONLY the link-check verdict, not the full ci.yml suite.
Includes a concurrency-block to cancel superseded same-ref runs;
keeps the existing ci.yml link-check job in place as a defensive
gate.

Adds project-level .actrc pinning ubuntu-latest to
catthehacker/ubuntu:act-22.04 (Node 22 pre-installed) and dropping
the --no-skip-checkout flag so act uses the bind-mounted working tree
directly (clears the local-sandbox in-container Missing-script
symptom documented in the file header).

Appends the link-check status badge line to all 4 README files
(en + zh-CN + ja-JP + ko-KR). Promotes a captured link-check.log
record to artifacts/link-check.log as the canonical green-CI
verdict for this branch (regenerable by running act locally).

… hosted runners

The link-check script defaults `dev-fixtures/README.md` into its 6-file scope. Previously the file existed only in the local working tree (untracked, never committed) — so `actions/checkout@v4` would not materialize it for the GitHub-hosted link-check job, the script would fail with ENOENT at extractHeadings, and the link-check badge would never light green on github.com even though `npm run check-links` passed in the same sandbox.\n\nTracking the README is the minimal fix: it documents the `make watch` workflow + the local-fixture contract (what gets committed: README.md, aws.html, messages_route.js; what stays .gitignored: state/, .receiver.port, .receiver.pid, receiver.log) and is referenced as a contribution guide for new contributors. The other fixture files (aws.html, messages_route.js, the dynamic state directory) remain local-only on purpose (per the README itself).\n\nVerifies on a GitHub-hosted runner: after push, the link-check job exits 0 with `PASS: 21 cross-link(s) across 6 README file(s) resolve correctly.`

…flow)

The `link-check` job in this workflow was a safe early-deployment\nduplicate — when there was no dedicated `.github/workflows/link-check.yml`\nyet, running the checker here gave the ci.yml its own badge. That job\nis now obsolete: the dedicated workflow at `.github/workflows/link-check.yml`\nis the sole gate, has its own status badge line in each locale README,\nand runs on its own concurrency group.\n\nDrops the job block (and its 9-line "different class of regressions"\ncomment prefix) so this workflow keeps only its two non-link jobs:\n  1. watch-once-fixture  — make watch-once against fixture mutation\n  2. pack-tarball-clean  — npm pack --dry-run + exclusion assertions\n\nNo `needs: link-check` references were broken by this removal — both\nremaining jobs ran independently and continue to.

…delegated

After dropping the redundant link-check job from this workflow,\nadd a short tombstone paragraph at the bottom of the top-of-file\ncomment block so a future contributor reading ci.yml and wondering\n"is the link-check job missing by mistake?" can see immediately\nthat it was deliberate and where it lives now.\n\nThe note points at `.github/workflows/link-check.yml` as the\nauthoritative source rather than pinning a specific commit SHA\n(git history can be rewritten; file paths cannot).

`evolver/artifacts/` was a single-root captured-evidence tree (`link-check.log` + a `README.md` provenance doc). For the new per-branch feature (commit just below), the layout splits:

- legacy `artifacts/link-check.log` becomes `artifacts/main/link-check.log` so the canonical green/red verdict at HEAD still has a durable home.
- per-PR captures land under `artifacts/<branch>/` in the runner workspace during the run AND as GH-named artifacts on the run — the runner copies are ephemeral and reviewers reach them via the PR Checks → Artifacts tab.

This commit is just the structural move + README refresh; the workflow changes that produce the per-branch namespace are in the prior commit. `git mv` preserves the file history (no rename attribution loss).

…h re-triggers

On default `pull_request` events, the dev-only workflow's `git push` to the PR source branch is denied (GITHUB_TOKEN is read-only), so the `[skip ci]` tag is harmless noise in that case.\n\nThe case the tag actually matters: a future switch to `pull_request_target` (where the token scope would let the push succeed). With `[skip ci]`, a successful commit-to-PR would NOT re-trigger the dev-only workflow, so the capture file added by the commit would never be reflected in a re-run unless something else nudges it.\n\nDropping the tag means a successful push re-triggers the dev-only check, which re-captures with the new file present — closes the loop correctly.\n\nThe strict workflow's auto-commit (push-to-main only) keeps its `[skip ci]` because that push is on every direct push to main and would loop infinitely otherwise — the dev-only has no equivalent loop hazard because the source branch is the user's PR branch, not main.

…back parity, Bedrock alias drift

test/extensions.test.js: add explicit validation cases for normalizeCreatePayload clamping (max_participants, malformed timestamps, mixed-case tags) so a future regression in the extension handler CANNOT silently relax those clamps. test/proxyServer.test.js: add an integration test that drives the Session routes through their fallback path and asserts the fallback applies the same input validation as SessionHandler — locks the parity contract between the two surfaces. test/routerCanonicalizeBedrock.test.js: add a "tripwire" test that probes a small AWS-docs fixture for new Bedrock models not yet canonicalized into KNOWN_BEDROCK_ALIASES, so the next contributor who adds a Bedrock model gets a deterministic signal that ALL surfaces (messages_route, proxy server, sessionHandler) need a corresponding alias before the canonicalize step accepts the new model.

…ndler; routes adopt normalizeOr400

src/proxy/extensions/sessionHandler.js: extract pure validation/normalization helpers (normalizeCreatePayload, normalizeMessagePayload, normalizeDelegatePayload) and the contract constants (MAX_PARTICIPANTS, MAX_PAYLOAD_BYTES) out of the inline route bodies and into the SessionHandler module so both the Session-handler extension and the proxy/server routes enforce the same contract from one source. Behavior is unchanged \u2014 a 400 with the same JSON shape comes back when a payload fails the contract.\n\nsrc/proxy/server/routes.js: replace inline 400-throwing validates with normalizeOr400(value, kind) which wraps the validator and returns a normalized value or an Express 400 response. Net -22 lines while adding the contract seam; route bodies become declarative (just kind + handler) instead of mixing contract logic with proxy plumbing. Public exports unchanged in both files (no API surface drift).

…ch-tail targets

Four phony targets wrapping scripts/dev-watch.sh so a contributor can iterate against the local Slack receiver without remembering the env-var dance:\n  - make watch         WATCH_INTERVAL=60 (override: WATCH_INTERVAL=10 make watch)\n  - make watch-fresh   clear dev-fixtures/state, then watch\n  - make watch-once    single run, no loop\n  - make watch-tail    tail dev-fixtures/receiver.log (for a second terminal while watch is running elsewhere)\n\nDocumented in README.md / README.ko-KR.md / README.zh-CN.md already (161+ references to the targets cross the repo). This commit adds the implementation so the docs are no longer aspirational.

…versationDistiller

A 57-line driver that:\n  - shims EVOLVER_SETTINGS_DIR to /tmp/distill-debug-$pid so the run does not touch committed state\n  - does a require smoke-test on ./src/gep/conversationDistiller (logs exported names + fails loudly with the top 12 stack frames on import error)\n  - exercises distillConversation against three concrete cases:\n      1. draft (persist:false, publish:false)\n      2. publish-only (persist:false default)\n      3. skipped (short summary)\n  - logs ok / status / reason so a contributor can scan the verdict in a single grep\n\nNot referenced in README by design \u2014 it is a scratch tool for someone hacking on the distill pipeline. The leading underscore is a developer convention to flag "ignore if you stumble on this"; no _* gitignore pattern exists in the repo so it would otherwise drift into the untracked pile forever. Committed under scripts/-style intent (root fixture) so the next gc cycle does not silently prune it as a 30-day-stale dangling blob.

…self-cleaning _distill-debug.js

Add a complete local-development harness for
scripts/bedrock-alias-watch.sh so the operator can edit the AWS-doc
fixture in real time and watch the resulting Slack payload without
waiting for the daily cron:

- scripts/bedrock-alias-watch.sh: The production watcher. Daily cron
  diffs the live AWS Bedrock supported-models doc against
  KNOWN_BEDROCK_ALIASES in src/proxy/router/messages_route.js and
  posts a Slack message when the canonical table needs a new entry,
  a dated-revision bump, or a retirement. Three diff layers (new
  family/major/minor, dated revision, retired) suppress cross-region
  siblings the canonicalizer already handles, plus idempotent seen_*
  tracking so re-runs do not double-post.

- scripts/dev-watch.sh: A developer-mode looping runner. Spawns the
  local Slack receiver, points MESSAGES_ROUTE_FILE at
  dev-fixtures/messages_route.js, points AWS_BEDROCK_URL at
  file://dev-fixtures/aws.html, and re-runs the watcher every
  WATCH_INTERVAL seconds (default 60). Ctrl-C cleans up the receiver
  and exits. Pairs with make watch, make watch-once.

- scripts/dev-slack-receiver.js: A 60-line http.createServer on
  127.0.0.1 with a random port (so it cannot collide). Writes the
  chosen port to --port-file and appends each POST body to --log-file
  (pretty-printed if JSON). Catches SIGINT/SIGTERM and shuts down
  cleanly so the parent watch loop does not leak processes on Ctrl-C.

- test/bedrock-alias-watch.test.js: Node --test port of the full
  11-block bash test harness. Each block spawns the bash script with
  a controlled environment, points it at a tmp-dir state + a file://
  mock AWS doc, and captures the alert via an in-process Slack
  receiver. Coverage: new-family detection, dated-revision was/now,
  retirement alert, came-back, DRY_RUN, AWS fetch fail, backwards-
  compat for round-1 seen_ids state files, SLACK_WEBHOOK_URL unset,
  idempotency on re-runs. All 11 it() blocks verified green under
  node --test in ~1.6s.

- dev-fixtures/aws.html, dev-fixtures/messages_route.js,
  dev-fixtures/.gitignore: Seeded fixtures the operator edits during
  make watch. .gitignore excludes runtime artifacts (state/,
  .receiver.port, .receiver.pid, receiver.log); the seeded fixtures
  themselves ARE committed.

This unblocks the edit-while-you-watch workflow that previously
required either modifying the live AWS URL or hand-running tests.
Pure developer ergonomics; no production-path change to the proxy
or the watcher itself.

Three latent polish items closed out in one atomic chore commit so PR
EvoMap#596 picks them up together. All three were deferrable from prior
review rounds; consolidated now to avoid further re-review churn.

(a) SKILL.md dm/send Auth note. The prior wording said the proxy was
"trusted by EvoMap Hub on behalf of the registered A2A_NODE_ID". This
was imprecise -- it implied the Hub attributed contributor calls back
to the caller. New wording explicitly notes that the proxy
authenticates to EvoMap Hub using its own A2A_NODE_ID-issued
credentials, and the contributor identity is not relayed. Agents on
the same machine call without Bearer / signature / API key, and the
proxy handles Hub-side authentication on its own behalf.

(b) SKILL.md dm/list row Notes column. Dropped the backticks around
offset in the limit row so it matches the plain-text Notes pattern
used by neighboring DM-table cells (Target node id, Message body,
Free-form structured metadata, Max messages to return, Skip first
N messages all use plain-text prose in their Notes).

(c) scripts/bedrock-alias-watch.sh. Refactored the hardcoded
"(global|us|eu|ap)" regional prefix alternation into a config-driven
BEDROCK_REGIONAL_PREFIXES env var (default global|us|eu|ap). Four
regex consumers now route through a single PREFIX_REGEX variable
which wraps the env var in (...) for proper ERE grouping
(without the (...) wrap, the bare alternation would parse as
"global OR us OR eu OR ap" in sed unanchored, which is not the
intended semantics):

- KNOWN extraction (grep on src/proxy/router/messages_route.js)
- canon derivation (sed in the canon map loop)
- AWS keys extraction (grep on the Bedrock doc HTML)
- AWS full-IDs extraction (grep on the Bedrock doc HTML)

Added a startup smoke check that warns when KNOWN_BEDROCK_ALIASES
contains a full-ID whose regional prefix is not in the configured
list -- catches the operator-forgot-to-extend gap (e.g. AWS adds
jp.* in some future quarter and the operator forgets to update
either the env var or the table) BEFORE the diff pass runs. The
check is a single cut + tr + grep -Fxq loop, cheap on thousands
of entries, idempotent on every run until the operator resolves.

Verification gates:
- npm run check-links: rc 0, PASS 21 cross-links (no anchor drift)
- node --test test/bedrock-alias-watch.test.js: rc 0, 11/11 it()
  blocks pass in ~1.6s. The env-var default preserves the
  original regex exactly; the smoke check fires only on out-of-
  list prefixes which the production KNOWN_BEDROCK_ALIASES table
  does not contain.
- bash -n syntax check on bedrock-alias-watch.sh: clean.

No production-path behaviour change for the four available regions
(or the thousands of historical ID states). The env var is opt-in:
if an operator does nothing, the script behaves identically to
before this commit.

CI gate that prevents the missed-migration pattern from the prior chore
commit (the (global|us|eu|ap) -> BEDROCK_REGIONAL_PREFIXES refactor)
from ever shipping again. Three file edits:

- package.json: adds check-bedrock-prefix npm script. The gate pipes
  grep -nF '(global|us|eu|ap)' scripts/bedrock-alias-watch.sh to
  filter out comment lines (grep -vE '^[0-9]+:[[:space:]]*#') and
  uses an if/then/else wrapper to orchestrate exit codes correctly:
  0 non-comment hits -> exit 0 (PASS); >=1 hit -> echo FAIL message +
  exit 1 (FAIL).

- .github/workflows/link-check.yml: inserts a new Step 2 step in the
  capture block that runs the new gate before the existing check-links
  (now Step 3). On push-to-main, the per-branch log captures the
  verdict; on PR events against main, the gate fails the workflow if
  a regression is detected.

- .github/workflows/link-check-dev.yml: same Step 2 insertion for the
  dev-only soft variant. Workflow-level continue-on-error: true means
  a regression shows as a red advisory check on PRs but does not
  block merge.

Design notes:

- grep -nF (fixed-string) is used instead of grep -nE so the JSON
  string has no regex-escaping concerns and the gate is robust against
  awk / perl / heredoc regressions, not just grep / sed. The original
  reviewer-suggested pipe ... || exit 0 is grammatically inverted
  (would always exit 0 regardless of hits) and not used.

- The if/then/else/fi wrapper makes the exit-code orchestration
  explicit and shell-portable (POSIX /bin/sh semantics confirmed by
  the test.yml Windows + macOS advisory run matrix).

- False-positive class: a non-comment line that legitimately mentions
  the literal. There are zero such lines in the current post-amend
  script (verified by dry-validation in the prior basher); if a
  future contributor adds one unintentionally that's not a regex
  context, the gate will surface it for editing rather than silently
  accepting.

Verification gates:
- npm run check-bedrock-prefix on current state: PASS (0 hits)
- npm run check-links: still PASS 21 cross-links
- node --test test/bedrock-alias-watch.test.js: still 11/11
- Negative smoke (pre-commit, reverted): gate cleanly exits 1 with
  the FAIL message when a regression line is added to the script;
  git checkout scripts/bedrock-alias-watch.sh restored clean state.

Adds a CI sentinel (`npm run check-bedrock-prefix`) that asserts no
hardcoded `(global|us|eu|ap)` regex literal appears in any non-comment
line of scripts/bedrock-alias-watch.sh. Also adds a caller-side fix
migrating the FTH substitution site (step 4b dated-revision sed at
line 193) from the hardcoded literal to `${PREFIX_REGEX}` so the gate
is green on this commit. Prior amend cycle's verifier reported 0 hits
before the force-push but the post-push state was actually missing
site #5; the CI sentinel itself caught the regression in the post-push
re-verify (gate exited 1 with FAIL message echoing line 193), which
is exactly what the sentinel was put in place to do.

Files:
  * package.json -- add `check-bedrock-prefix` script entry, three-stage
    fixed-string pipe wrapped in `if/then/else/fi`:
      stage 1: grep -nF '(global|us|eu|ap)' scripts/bedrock-alias-watch.sh
      stage 2: grep -vE '^[0-9]+:[[:space:]]*#'   # drop comment prose
      stage 3: if non-empty -> FAIL + exit 1, else exit 0.
  * .github/workflows/link-check.yml -- new Step 2 line
      `- name: Step 2: npm run check-bedrock-prefix`
      inserted before the existing Step 2 `check-links`, with Step
      numbers re-stamped to 3..N.
  * .github/workflows/link-check-dev.yml -- same insertion for the
    dev-only soft variant, identical numbering bump.
  * scripts/bedrock-alias-watch.sh -- single-line fix at line 193
    (step 4b dated-revision sed). Single-quoted sed literal replaced
    with a double-quoted form so `${PREFIX_REGEX}` expands:
      before: sed -E 's/^(global|us|eu|ap)\.anthropic\.claude-...'
      after:  sed -E "s/^${PREFIX_REGEX}\.anthropic\.claude-..."
    All five substitution sites (KNOWN extraction, two canon
    derivations, AWS keys extraction, AWS full-IDs extraction) now
    use `${PREFIX_REGEX}` and are config-driven by
    `BEDROCK_REGIONAL_PREFIXES` (default `global|us|eu|ap`).

Gate exit codes:
  * current source tree: exit 0 (all 5 sites migrated).
  * pre-fix source tree: exit 1 (line 193 would be flagged).

Why this gate exists: two amend cycles in this session were required
because the substitution-site enumeration undercounted (`grep -cE`
undercount, sed/grep contexts split across regex/sed). The gate
turns the missed-migration pattern into a build failure so a future
regression recreating it is caught at PR time, not after force-push.

Extends the smoke check (step 1b in scripts/bedrock-alias-watch.sh, the
'does any KNOWN prefix fall outside BEDROCK_REGIONAL_PREFIXES?' check)
with a NEW direction B: 'does any env-var token FALL OUTSIDE the
documented default AND lack a matching KNOWN_BEDROCK_ALIASES entry?'.
Catches operator typos (e.g. 'europe' instead of 'eu') without nagging
about legitimate extensions (e.g. 'jp') once the table is updated.
Inverse semantics from direction A: B fires when env has a token the
table has not caught up with; A fires when the table has an entry the
env has not caught up with.

Plus 2 new test cases (test/bedrock-alias-watch.test.js):

  Run 10: BEDROCK_REGIONAL_PREFIXES=us|eu|ap + production MOCK_JS.
    Direction A fires (3 global.* IDs flagged) — the 3 production
    entries have 'global' prefix which is not in the env var.
    Direction B is silent — env \ default is empty since us|eu|ap is
    a strict subset of the documented default 'global|us|eu|ap'.

  Run 11 (dual sub-case): BEDROCK_REGIONAL_PREFIXES=global|us|eu|ap|jp.
    Sub-case A: with production MOCK_JS only, direction B fires 1
    (the 'jp' token — non-default + no KNOWN coverage). Direction A
    is silent ('global' and 'jp' both appear in env).
    Sub-case B: with MOCK_JS + JP_MOCK_JS injection (one
    jp.anthropic.claude-opus-4-7 entry), direction B is silenced
    (legitimate extension, not a typo). JP_MOCK_JS constant
    configures the trailing-comma entry + closing brace injection
    via .replace(/\}\);\n?$/, JP_MOCK_JS).

Files:
  * scripts/bedrock-alias-watch.sh -- new step 1c block (~14 lines)
    inserted between step 1b's closing fi and step 2. Uses process
    substitution `< <(printf | tr | sort -u)` so the while loop stays
    in the parent shell (continue works across the loop body without
    implicit subshell). DEFAULT_PREFIXES = 'global|us|eu|ap' matches
    the documented default in the script header. KNOWN_PREFIXES_FILE
    extracts KNOWN prefixes via `cut -d. -f1`. EXTRA_TOKEN_FILE
    captures env tokens that are non-default + non-KNOWN.
  * test/bedrock-alias-watch.test.js -- runWatch({...}) extended to
    accept a `mockJs = MOCK_JS` param (default). JP_MOCK_JS constant
    + Run 10 + Run 11. Total test file delta: ~50 lines.

Gate (npm run check-bedrock-prefix) remains green -- the literal
'(global|us|eu|ap)' is not introduced in any regex/sed context by
this change. The new code uses the unparenthesized default token list,
which the gate's regex (which requires the literal parens) does NOT
match.

All gates re-verified: bash -n clean, npm test 13/13, npm run
check-links clean, gate clean, git fsck clean.